package Logica;

import com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable;
import java.util.ArrayList;

public class ChessTrainer {
    private String tablero[][]=new String[6][6];;
    int posFichas[][]=new int[16][2];
    String[]fichas={"p","P","p","P","p","P","p","P","b","B","h","H","q","Q","k","K"};
    ArrayList<Integer[]> posicionesGeneradas=new ArrayList();
    int posiciones[][]=new int[16][2];

    public ChessTrainer() {
        
        
        
    } 
    
    public int[][] GenerarPosicionesAleatorias()
    {
        do{
            for(int i=0;i<16;i++)
            {
                int x=(int) (Math.random()*6);
                int y=(int) (Math.random()*6);
                 if(!posicionesGeneradas.contains(new Integer[]{x,y}))
                 {
                     posicionesGeneradas.add(new Integer[]{x,y});
                     posFichas[i]=new int[]{x,y};
                 }
            }   
        }
        while(new Nodo(posFichas, null, null, 0, 0).Jaque(0));  
        return posFichas;
    }
   
   
   int CalcularHeuristica()
   {
       int heuristica = 0;
       return heuristica;
   }
    
    boolean Jaque(int color)
    {
        boolean jaque=false;
        int i;
        int rey[]=new int[2];
        if(color==0)
        {
            
        }
        else{
            
        }
        return jaque;
    }
    
    ArrayList<Nodo> AlgoritmoMinimax(Nodo actual,int profundidad)
    {
        Hashtable arbolGenerado=new Hashtable(100);
        ArrayList<Nodo> hijos=new ArrayList(); 
        ArrayList<Nodo> recorrido=new ArrayList(); 
        int color=actual.color;
        if(actual.profundidad==profundidad)
        {
            if((actual.profundidad%2)==0){
                hijos=actual.DeterminarPosiblesJugadas(color);
                arbolGenerado.put(new Object[]{actual.posiciones,actual.color}, hijos);
                recorrido.add((DecisionMax(hijos)));
            }
            else{
                hijos=actual.DeterminarPosiblesJugadas(color);
                arbolGenerado.put(new Object[]{actual.posiciones,actual.color}, hijos);
                recorrido.add((DecisionMin(hijos)));
            }
        }else{
           hijos=actual.DeterminarPosiblesJugadas(color);
           ArrayList<Nodo> movHijos=new ArrayList(); 
            for (int i = 0; i < hijos.size(); i++) {
                Nodo nodo = hijos.get(i);
                if((actual.profundidad%2)==0){
                    movHijos=nodo.DeterminarPosiblesJugadas(color);
                    arbolGenerado.put(new Object[]{actual.posiciones,actual.color}, movHijos);
                    recorrido.add((DecisionMax(movHijos)));
                }
                else
                {
                    movHijos=nodo.DeterminarPosiblesJugadas(color);
                    arbolGenerado.put(new Object[]{actual.posiciones,actual.color}, movHijos);
                    recorrido.add((DecisionMin(movHijos)));
                }
            }
        }
        
        return recorrido;
    }
    
    public Nodo DecisionMin(ArrayList<Nodo> hijos)
    {
        Nodo minimo=hijos.get(0);
        int costo=minimo.CalcularHeuristica();
        for (int i = 0; i < hijos.size(); i++) {
            if(hijos.get(i).CalcularHeuristica()<costo){
                minimo=hijos.get(i);
                costo=hijos.get(i).CalcularHeuristica();
            }
        }
        return minimo;
    }
    
    public Nodo DecisionMax(ArrayList<Nodo> hijos)
    {
        Nodo maximo=hijos.get(0);
        int costo=maximo.CalcularHeuristica();
        for (int i = 0; i < hijos.size(); i++) {
            if(hijos.get(i).CalcularHeuristica()>costo){
                maximo=hijos.get(i);
                costo=hijos.get(i).CalcularHeuristica();
            }
        }
        return maximo;
    }
}

